

import pandas as pd
import json
import re
from pathlib import Path
import os
import traceback

def extract_traffic_info_from_text(text):

    if pd.isna(text) or not isinstance(text, str):
        return {
            'vehicle_count': None,
            'road_length': None,
            'year': None,
            'station_count': None,
            'bridge_count': None
        }
    
    result = {
        'vehicle_count': None,
        'road_length': None,
        'year': None,
        'station_count': None,
        'bridge_count': None
    }
    
    # 1. 提取年份信息（支持多种格式）
    year_patterns = [
        r'(\d{3,4})\s*年',                          # 直接年份：1234年
        r'公元\s*(\d{3,4})',                        # 公元年份：公元1234
        r'(\w+?)\s*元年\s*（(\d{3,4})年）',          # 年号元年：洪武元年（1368年）
        r'(\w+?)\s*(\d+)\s*年\s*（(\d{3,4})年）',    # 年号年份：乾隆10年（1745年）
        r'(\d{1,2})\s*世纪\s*(\d{2,4})\s*年代',      # 世纪年代：19世纪80年代
        r'(\d{4})\s*[-—至]\s*(\d{4})\s*年',          # 年份范围：1900-1910年
        r'(\d{4})\s*年\s*[-—至]\s*(\d{4})\s*年'      # 年份范围：1900年至1910年
    ]
    
    for pattern in year_patterns:
        matches = re.findall(pattern, text)
        if matches:
            for match in matches:
                if isinstance(match, tuple):
                    # 处理包含多个捕获组的匹配结果
                    for group in match:
                        if group.isdigit() and len(group) >= 3:
                            result['year'] = int(group)
                            break
                elif match.isdigit() and len(match) >= 3:
                    result['year'] = int(match)
                    break
        if result['year']:
            break  # 找到第一个有效年份后退出
    
    # 2. 提取交通工具数量（车辆、马匹、船只等）
    vehicle_patterns = [
        r'(\d+)\s*(乘|辆|艘|匹)\s*(车|马|船|轿)',    # 具体数量：100乘车、500匹马
        r'千乘之国',                                # 特殊表述：千乘之国（1000乘）
        r'万乘之君',                                # 特殊表述：万乘之君（10000乘）
        r'(\d+)\s*千\s*(乘|辆|艘)',                 # 千单位：5千乘、3千辆
        r'(\d+)\s*万\s*(乘|辆|艘)',                 # 万单位：2万乘、1万辆
        r'(\d+)\s*余\s*(乘|辆|艘|匹)'               # 有余数量：500余乘、1000余匹
    ]
    
    for pattern in vehicle_patterns:
        match = re.search(pattern, text)
        if match:
            if '千乘之国' in pattern:
                result['vehicle_count'] = 1000
            elif '万乘之君' in pattern:
                result['vehicle_count'] = 10000
            else:
                try:
                    num = int(match.group(1))
                    if '千' in pattern:
                        result['vehicle_count'] = num * 1000
                    elif '万' in pattern:
                        result['vehicle_count'] = num * 10000
                    else:
                        result['vehicle_count'] = num  # 普通数量和有余数量
                except (ValueError, IndexError):
                    pass
        if result['vehicle_count']:
            break
    
    # 3. 提取道路长度（统一转换为公里）
    road_patterns = [
        r'(\d+)\s*(里|公里|千米)\s*路',              # 直接表述：100里路、50公里路
        r'道路长\s*(\d+)\s*(里|公里|千米)',          # 明确长度：道路长200里
        r'(\d+)\s*里\s*之遥',                       # 距离表述：150里之遥
        r'(\d+)\s*千\s*(里|公里|千米)',             # 千单位：5千里、3千公里
        r'长\s*(\d+)\s*(里|公里|千米)'              # 简洁表述：长300里
    ]
    
    for pattern in road_patterns:
        match = re.search(pattern, text)
        if match:
            try:
                num = int(match.group(1))
                if '千' in pattern:
                    base_length = num * 1000
                else:
                    base_length = num
                
                # 单位转换：1里 = 0.5公里
                if '里' in pattern and '千' not in pattern:
                    result['road_length'] = round(base_length * 0.5, 1)
                else:
                    result['road_length'] = base_length
            except (ValueError, IndexError):
                pass
        if result['road_length']:
            break
    
    # 4. 提取驿站数量
    station_patterns = [
        r'(\d+)\s*(个|处|所)\s*驿站',                # 完整表述：50个驿站、30处驿站
        r'驿站\s*(\d+)\s*(个|处|所)',                # 倒装表述：驿站20个、驿站15处
        r'(\d+)\s*驿',                               # 简洁表述：30驿、45驿
        r'设驿\s*(\d+)\s*(处|个)'                    # 建设表述：设驿10处、设驿8个
    ]
    
    for pattern in station_patterns:
        match = re.search(pattern, text)
        if match:
            try:
                result['station_count'] = int(match.group(1))
            except (ValueError, IndexError):
                pass
        if result['station_count']:
            break
    
    # 5. 提取桥梁数量
    bridge_patterns = [
        r'(\d+)\s*(座|处)\s*桥梁',                  # 完整表述：20座桥梁、15处桥梁
        r'桥梁\s*(\d+)\s*(座|处)',                  # 倒装表述：桥梁10座、桥梁8处
        r'建桥\s*(\d+)\s*(座|处)',                  # 建设表述：建桥12座、建桥5处
        r'(\d+)\s*座\s*桥'                          # 简洁表述：8座桥、15座桥
    ]
    
    for pattern in bridge_patterns:
        match = re.search(pattern, text)
        if match:
            try:
                result['bridge_count'] = int(match.group(1))
            except (ValueError, IndexError):
                pass
        if result['bridge_count']:
            break
    
    return result

def extract_traffic_data_from_excel(file_path, sheet_names=None):
    """
    从Excel文件中提取交通数据，处理多个sheet
    
    参数:
        file_path (str): Excel文件路径
        sheet_names (list): 要处理的sheet名称列表，None表示处理所有sheet
        
    返回:
        list: 提取的交通数据列表，每个元素是包含结构化信息的字典
    """
    try:
        # 验证文件存在性
        if not os.path.exists(file_path):
            print(f"错误：文件不存在 - {file_path}")
            return []
        
        # 获取所有sheet名称（如果未指定）
        if sheet_names is None:
            excel_file = pd.ExcelFile(file_path)
            sheet_names = excel_file.sheet_names
        
        all_results = []
        print(f"开始处理 {len(sheet_names)} 个sheet: {sheet_names}")
        
        for sheet_name in sheet_names:
            print(f"\n正在处理sheet: {sheet_name}")
            
            try:
                # 读取当前sheet数据
                df = pd.read_excel(file_path, sheet_name=sheet_name)
                print(f"  - 读取到 {len(df)} 行数据")
                
                # 处理列名，确保关键列存在
                column_mapping = {}
                
                # 1. 处理时期列
                if '时期' in df.columns:
                    column_mapping['category'] = '时期'
                else:
                    # 检查第一行是否为标题行
                    if len(df) > 0 and (df.iloc[0, 0] == '时期' or '时期' in str(df.iloc[0, 0])):
                        # 使用第一行作为列名
                        df.columns = df.iloc[0]
                        df = df.iloc[1:].reset_index(drop=True)
                        if '时期' in df.columns:
                            column_mapping['category'] = '时期'
                        else:
                            column_mapping['category'] = df.columns[0]
                    else:
                        # 使用第一列作为时期列
                        column_mapping['category'] = df.columns[0]
                
                # 2. 处理原文列（三级列）
                if '三级' in df.columns:
                    column_mapping['content'] = '三级'
                else:
                    # 自动识别包含大量文本的列作为原文列
                    text_column_candidates = []
                    for col in df.columns:
                        if df[col].dtype == 'object':
                            # 计算平均文本长度
                            avg_length = df[col].apply(
                                lambda x: len(str(x)) if pd.notna(x) else 0
                            ).mean()
                            text_column_candidates.append((avg_length, col))
                    
                    # 选择平均长度最长的列作为原文列
                    if text_column_candidates:
                        text_column_candidates.sort(reverse=True)
                        column_mapping['content'] = text_column_candidates[0][1]
                        print(f"  - 自动识别原文列: {column_mapping['content']}")
                    else:
                        print(f"  - 警告: 未找到合适的原文列，跳过此sheet")
                        continue
                
                # 3. 处理交通工具列（四级列）
                if '四级（对“原文”的拆分）' in df.columns:
                    column_mapping['vehicle'] = '四级（对“原文”的拆分）'
                else:
                    column_mapping['vehicle'] = None
                
                # 4. 处理交通要道列（Unnamed: 4）
                if 'Unnamed: 4' in df.columns:
                    column_mapping['road'] = 'Unnamed: 4'
                else:
                    # 寻找可能的交通要道列
                    road_column_candidates = []
                    for col in df.columns:
                        if col not in [column_mapping['category'], column_mapping['content']]:
                            # 检查该列是否包含道路相关词汇
                            road_keywords = ['路', '道', '驿', '桥', '关', '口']
                            if df[col].dtype == 'object':
                                contains_road = df[col].apply(
                                    lambda x: any(keyword in str(x) for keyword in road_keywords) 
                                    if pd.notna(x) else False
                                ).sum()
                                if contains_road > 0:
                                    road_column_candidates.append((contains_road, col))
                    
                    if road_column_candidates:
                        road_column_candidates.sort(reverse=True)
                        column_mapping['road'] = road_column_candidates[0][1]
                        print(f"  - 自动识别交通要道列: {column_mapping['road']}")
                    else:
                        column_mapping['road'] = None
                
                # 5. 处理出处列（Unnamed: 2）
                if 'Unnamed: 2' in df.columns:
                    column_mapping['source'] = 'Unnamed: 2'
                else:
                    column_mapping['source'] = None
                
                # 遍历处理每一行数据
                valid_records = 0
                for idx, row in df.iterrows():
                    # 获取时期/朝代信息
                    category_val = row[column_mapping['category']] if pd.notna(row[column_mapping['category']]) else None
                    if not category_val:
                        continue  # 跳过没有时期信息的行
                    
                    # 获取原文内容
                    content_val = row[column_mapping['content']] if pd.notna(row[column_mapping['content']]) else ""
                    
                    # 获取交通工具信息
                    vehicle_val = None
                    if column_mapping['vehicle'] and pd.notna(row[column_mapping['vehicle']]):
                        vehicle_val = str(row[column_mapping['vehicle']]).strip()
                        # 过滤无意义的标注
                        if vehicle_val in ['无', '暂无', '未提及', 'None', 'nan']:
                            vehicle_val = None
                        else:
                            # 标准化分隔符
                            vehicle_val = vehicle_val.replace('、', '，')
                    
                    # 获取交通要道信息
                    road_val = None
                    if column_mapping['road'] and pd.notna(row[column_mapping['road']]):
                        road_val = str(row[column_mapping['road']]).strip()
                        # 过滤无意义的标注
                        if road_val in ['无', '暂无', '未提及', 'None', 'nan']:
                            road_val = None
                        else:
                            # 标准化分隔符
                            road_val = road_val.replace('、', '，')
                    
                    # 获取出处信息
                    source_val = None
                    if column_mapping['source'] and pd.notna(row[column_mapping['source']]):
                        source_val = str(row[column_mapping['source']]).strip()
                    
                    # 从原文中提取量化信息
                    extracted_info = extract_traffic_info_from_text(str(content_val))
                    
                    # 创建结构化数据记录
                    record = {
                        'category': str(category_val).strip(),  # 时期/朝代
                        'sheet_name': sheet_name,               # 数据来源sheet
                        'vehicle_type': vehicle_val,            # 交通工具类型
                        'road_type': road_val,                  # 交通要道类型
                        'vehicle_count': extracted_info['vehicle_count'],  # 交通工具数量
                        'road_length': extracted_info['road_length'],      # 道路长度（公里）
                        'station_count': extracted_info['station_count'],  # 驿站数量
                        'bridge_count': extracted_info['bridge_count'],    # 桥梁数量
                        'year': extracted_info['year'],          # 具体年份
                        'original_text': str(content_val)[:1000] + '...' if len(str(content_val)) > 1000 else str(content_val),  # 原文摘要
                        'source': source_val                    # 文献出处
                    }
                    
                    # 只保留至少包含一项有效信息的记录
                    if any([
                        record['vehicle_type'], record['road_type'],
                        record['vehicle_count'], record['road_length'],
                        record['station_count'], record['bridge_count'],
                        record['year']
                    ]):
                        all_results.append(record)
                        valid_records += 1
                
                print(f"  - 提取到 {valid_records} 条有效记录")
                
            except Exception as e:
                print(f"  - 处理sheet '{sheet_name}' 时出错: {str(e)}")
                print(f"  - 错误详情: {traceback.format_exc()}")
                continue
        
        print(f"\n所有sheet处理完成，共提取到 {len(all_results)} 条有效交通数据记录")
        return all_results
    
    except Exception as e:
        print(f"读取Excel文件时发生严重错误: {str(e)}")
        print(f"错误详情: {traceback.format_exc()}")
        return []

def save_traffic_data(traffic_data, output_dir='./outputs'):
    """
    保存交通数据到JSON和Excel文件
    
    参数:
        traffic_data (list): 提取的交通数据列表
        output_dir (str): 输出目录路径
        
    返回:
        dict: 包含输出文件路径的字典
    """
    try:
        # 创建输出目录
        Path(output_dir).mkdir(parents=True, exist_ok=True)
        print(f"\n输出目录: {os.path.abspath(output_dir)}")
        
        # 定义输出文件路径
        json_file_path = os.path.join(output_dir, 'traffic_data.json')
        excel_file_path = os.path.join(output_dir, 'traffic_data_processed.xlsx')
        
        # 1. 保存为JSON文件
        with open(json_file_path, 'w', encoding='utf-8') as f:
            json.dump(traffic_data, f, ensure_ascii=False, indent=2)
        print(f"✅ JSON文件已保存: {os.path.basename(json_file_path)}")
        
        # 2. 保存为Excel文件（包含原始数据和汇总数据）
        if traffic_data:
            # 转换为DataFrame
            traffic_df = pd.DataFrame(traffic_data)
            
            # 定义列的显示顺序
            column_order = [
                'category', 'sheet_name', 'year', 'vehicle_type', 'vehicle_count',
                'road_type', 'road_length', 'station_count', 'bridge_count',
                'source', 'original_text'
            ]
            
            # 确保所有列都存在于DataFrame中
            for col in column_order:
                if col not in traffic_df.columns:
                    traffic_df[col] = None
            
            # 重新排列列顺序
            traffic_df = traffic_df[column_order]
            
            # 创建Excel写入器
            with pd.ExcelWriter(excel_file_path, engine='openpyxl') as writer:
                # 写入原始数据
                traffic_df.to_excel(writer, sheet_name='交通数据汇总', index=False)
                
                # 生成并写入按时期汇总的数据
                if 'category' in traffic_df.columns:
                    summary_by_category = traffic_df.groupby('category').agg({
                        'year': lambda x: ', '.join(str(y) for y in x.dropna().unique()[:5]),  # 最多显示5个年份
                        'vehicle_type': lambda x: ', '.join(str(y) for y in x.dropna().unique()[:10]),  # 最多显示10个交通工具类型
                        'road_type': lambda x: ', '.join(str(y) for y in x.dropna().unique()[:10]),  # 最多显示10个交通要道类型
                        'vehicle_count': lambda x: ', '.join(str(y) for y in x.dropna().unique()),
                        'road_length': lambda x: ', '.join(str(y) for y in x.dropna().unique()),
                        'station_count': lambda x: ', '.join(str(y) for y in x.dropna().unique()),
                        'bridge_count': lambda x: ', '.join(str(y) for y in x.dropna().unique()),
                        'source': lambda x: ', '.join(str(y) for y in x.dropna().unique()[:3])  # 最多显示3个出处
                    }).reset_index()
                    
                    summary_by_category.to_excel(writer, sheet_name='按时期汇总', index=False)
            
            print(f"✅ Excel文件已保存: {os.path.basename(excel_file_path)}")
        else:
            print("⚠️  没有有效数据可保存到Excel文件")
            excel_file_path = None
        
        return {
            'json_file': json_file_path,
            'excel_file': excel_file_path,
            'record_count': len(traffic_data)
        }
    
    except Exception as e:
        print(f"保存数据时出错: {str(e)}")
        print(f"错误详情: {traceback.format_exc()}")
        return {'error': str(e)}

def analyze_traffic_data(traffic_data):
    """
    分析交通数据，生成统计报告
    
    参数:
        traffic_data (list): 提取的交通数据列表
        
    返回:
        dict: 数据统计信息字典
    """
    if not traffic_data:
        return {'error': '没有可用的交通数据进行分析'}
    
    print(f"\n=== 交通数据统计分析报告 ===")
    
    # 基础统计
    total_records = len(traffic_data)
    print(f"1. 总体统计")
    print(f"   - 总记录数: {total_records} 条")
    
    # 按时期统计
    categories = [record['category'] for record in traffic_data]
    unique_categories = list(set(categories))
    print(f"   - 时期覆盖: {len(unique_categories)} 个不同时期")
    
    # 按数据类型统计
    data_type_stats = {
        '交通工具类型记录': sum(1 for record in traffic_data if record['vehicle_type']),
        '交通要道类型记录': sum(1 for record in traffic_data if record['road_type']),
        '包含具体年份记录': sum(1 for record in traffic_data if record['year'] is not None),
        '包含交通工具数量记录': sum(1 for record in traffic_data if record['vehicle_count'] is not None),
        '包含道路长度记录': sum(1 for record in traffic_data if record['road_length'] is not None),
        '包含驿站数量记录': sum(1 for record in traffic_data if record['station_count'] is not None),
        '包含桥梁数量记录': sum(1 for record in traffic_data if record['bridge_count'] is not None)
    }
    
    print(f"2. 数据类型分布")
    for data_type, count in data_type_stats.items():
        percentage = (count / total_records) * 100 if total_records > 0 else 0
        print(f"   - {data_type}: {count} 条 ({percentage:.1f}%)")
    
    # 按来源sheet统计
    sheet_stats = {}
    for record in traffic_data:
        sheet_name = record['sheet_name']
        sheet_stats[sheet_name] = sheet_stats.get(sheet_name, 0) + 1
    
    print(f"3. 数据来源分布（按sheet）")
    for sheet_name, count in sorted(sheet_stats.items()):
        percentage = (count / total_records) * 100 if total_records > 0 else 0
        print(f"   - {sheet_name}: {count} 条 ({percentage:.1f}%)")
    
    # 年份统计（如果有年份数据）
    years = [record['year'] for record in traffic_data if record['year'] is not None]
    if years:
        min_year = min(years)
        max_year = max(years)
        print(f"4. 年份范围统计")
        print(f"   - 时间跨度: {min_year} 年 - {max_year} 年")
        print(f"   - 覆盖年限: {max_year - min_year + 1} 年")
    
    # 交通工具数量统计（如果有数量数据）
    vehicle_counts = [record['vehicle_count'] for record in traffic_data if record['vehicle_count'] is not None]
    if vehicle_counts:
        avg_vehicles = sum(vehicle_counts) / len(vehicle_counts)
        print(f"5. 交通工具数量统计")
        print(f"   - 平均数量: {avg_vehicles:.0f} 单位")
        print(f"   - 最大数量: {max(vehicle_counts)} 单位")
        print(f"   - 最小数量: {min(vehicle_counts)} 单位")
    
    # 道路长度统计（如果有长度数据）
    road_lengths = [record['road_length'] for record in traffic_data if record['road_length'] is not None]
    if road_lengths:
        total_road_length = sum(road_lengths)
        avg_road_length = total_road_length / len(road_lengths)
        print(f"6. 道路长度统计")
        print(f"   - 总长度: {total_road_length:.1f} 公里")
        print(f"   - 平均长度: {avg_road_length:.1f} 公里")
        print(f"   - 最长道路: {max(road_lengths):.1f} 公里")
        print(f"   - 最短道路: {min(road_lengths):.1f} 公里")
    
    return {
        'total_records': total_records,
        'unique_categories': len(unique_categories),
        'data_type_stats': data_type_stats,
        'sheet_stats': sheet_stats,
        'year_stats': {'min_year': min(years) if years else None, 'max_year': max(years) if years else None},
        'vehicle_stats': {'avg': avg_vehicles if vehicle_counts else None, 'max': max(vehicle_counts) if vehicle_counts else None, 'min': min(vehicle_counts) if vehicle_counts else None},
        'road_stats': {'total': total_road_length if road_lengths else None, 'avg': avg_road_length if road_lengths else None, 'max': max(road_lengths) if road_lengths else None, 'min': min(road_lengths) if road_lengths else None}
    }

def display_sample_data(traffic_data, sample_count=5):
    """
    显示数据样本
    
    参数:
        traffic_data (list): 提取的交通数据列表
        sample_count (int): 显示的样本数量
    """
    if not traffic_data:
        print("没有可用的数据样本")
        return
    
    print(f"\n=== 交通数据样本（前 {min(sample_count, len(traffic_data))} 条记录） ===")
    
    for i, record in enumerate(traffic_data[:sample_count], 1):
        print(f"\n【样本 {i}】")
        print(f"时期: {record['category']}")
        print(f"数据来源: {record['sheet_name']}")
        print(f"年份: {record['year'] if record['year'] is not None else '未提及'}")
        print(f"交通工具类型: {record['vehicle_type'] if record['vehicle_type'] is not None else '未提及'}")
        
        if record['vehicle_count'] is not None:
            print(f"交通工具数量: {record['vehicle_count']} 单位")
        
        print(f"交通要道类型: {record['road_type'] if record['road_type'] is not None else '未提及'}")
        
        if record['road_length'] is not None:
            print(f"道路长度: {record['road_length']} 公里")
        
        if record['station_count'] is not None:
            print(f"驿站数量: {record['station_count']} 个")
        
        if record['bridge_count'] is not None:
            print(f"桥梁数量: {record['bridge_count']} 座")
        
        if record['source']:
            source_display = record['source'][:80] + '...' if len(record['source']) > 80 else record['source']
            print(f"文献出处: {source_display}")
        
        # 显示原文摘要
        text_display = record['original_text'][:150] + '...' if len(record['original_text']) > 150 else record['original_text']
        print(f"原文摘要: {text_display}")
        
        print("-" * 80)

def main():
    """
    主函数 - 交通数据提取与分析的入口点
    """
    print("=" * 80)
    print("          交通历史数据提取与分析工具          ")
    print("=" * 80)
    
    # 配置参数（用户可根据实际情况修改）
    config = {
        'input_file': './data/16交通 - 总数据和各朝代数据.xlsx',  # 输入Excel文件路径
        'output_dir': './outputs',             # 输出目录
        'sample_count': 5,                                 # 显示的样本数量
        'specific_sheets': None                            # 特定处理的sheet列表，None表示处理所有
    }
    
    print(f"\n当前配置:")
    print(f"  - 输入文件: {config['input_file']}")
    print(f"  - 输出目录: {config['output_dir']}")
    print(f"  - 样本显示数量: {config['sample_count']}")
    print(f"  - 处理sheet: {'所有sheet' if config['specific_sheets'] is None else config['specific_sheets']}")
    
    # 步骤1: 验证输入文件
    if not os.path.exists(config['input_file']):
        print(f"\n❌ 错误: 输入文件不存在 - {config['input_file']}")
        print("   请检查文件路径是否正确，或修改config中的'input_file'参数")
        return
    
    # 步骤2: 提取交通数据
    print(f"\n【步骤1/4】开始从Excel文件中提取交通数据...")
    traffic_data = extract_traffic_data_from_excel(
        file_path=config['input_file'],
        sheet_names=config['specific_sheets']
    )
    
    if not traffic_data:
        print("❌ 数据提取失败，没有获取到有效数据")
        return
    
    # 步骤3: 显示数据样本
    print(f"\n【步骤2/4】显示数据样本...")
    display_sample_data(traffic_data, config['sample_count'])
    
    # 步骤4: 数据分析
    print(f"\n【步骤3/4】进行数据统计分析...")
    analysis_result = analyze_traffic_data(traffic_data)
    
    # 步骤5: 保存数据
    print(f"\n【步骤4/4】保存数据到文件...")
    save_result = save_traffic_data(traffic_data, config['output_dir'])
    
    # 最终报告
    print(f"\n" + "=" * 80)
    print("                  处理完成报告                  ")
    print("=" * 80)
    print(f"📊 数据提取结果:")
    print(f"   - 成功提取 {len(traffic_data)} 条有效交通数据记录")
    print(f"   - 覆盖 {analysis_result['unique_categories']} 个不同历史时期")
    
    print(f"\n💾 输出文件:")
    if 'json_file' in save_result and save_result['json_file']:
        print(f"   - JSON格式: {os.path.abspath(save_result['json_file'])}")
    if 'excel_file' in save_result and save_result['excel_file']:
        print(f"   - Excel格式: {os.path.abspath(save_result['excel_file'])}")
        print(f"     (包含: 原始数据汇总表 + 按时期汇总表)")
    
    print(f"\n✅ 所有操作完成！")
    print(f"   数据文件已保存到: {os.path.abspath(config['output_dir'])}")
    print("=" * 80)

if __name__ == '__main__':
    # 确保安装了必要的依赖库
    try:
        import pandas as pd
        from openpyxl import Workbook
    except ImportError:
        print("检测到缺少必要的依赖库，正在尝试安装...")
        import subprocess
        import sys
        subprocess.check_call([sys.executable, "-m", "pip", "install", "pandas", "openpyxl", "xlrd"])
        print("依赖库安装完成，重新运行程序...")
        # 安装完成后重新导入
        import pandas as pd
        from openpyxl import Workbook
    
    # 执行主函数
    main()
